
Scilab – Open source software for numerical computation - zuron7
http://www.scilab.org/
======
joelthelion
This has been around for a while. However, it's clear to most people now that
Python/Scipy is a better solution, rather than simply trying to copy Matlab.
Python as a language is far, far better than Matlab. And the ecosystem has
matured a lot, to the point that for many research algorithms, the Python
offering is superior to the Matlab one.

~~~
chappi42
Agree with first sentence. Before mostly switching to R more than 10 years ago
I tried out Octave/Scilab (and preferred the latter).

As for the alternative I'd say, Julia is (will be) a good choice also. Long in
the making with a beautiful syntax which somewhat resembles Matlab. Sound
"inner" foundation. And speed. Speed like no other dynamic language (important
with increasing data abundance). Friendly and helpful community.

~~~
mbaha
I'm scared of network effects for Julia, personally. Python is garnering
tremendous amount of users.

But then, I remember a computer vision teacher 3 years ago laughing at the
idea of using Python instead of Matlab as Matlab is the "obvious industry
standard".

~~~
wallnuss
You are right that the current adoption rate of Python makes it seem like
Julia is in a losing position, but on the other hand it took Python a long
time to get in to the position it is right now and systemic changes take time.

The two arguments that speak for Julia from a user perspective (there exist
much stronger arguments for package developers).

a; Low overhead interoperability with Python, R, C and Fortran (and C++); You
don't need to rewrite your code and you can start using Julia and slowly
transition.

b; User code as fast as package/base library code. You are not stuck with what
already exists.

~~~
catawbasam
There are also some niches where Julia already has a strong position compared
to Python (which I use and like), e.g. optimization and differential
equations.

I think these are areas where the 2-language model makes Python quite a bit
less productive than Julia.

~~~
marmaduke
What do you not get with Numba that you'd want?

~~~
chappi42
Your question has been asked here [1]. I never used Numba myself but assume
from the discussion that it is difficult/impossible to bring user objects into
Numba and that due to the extremely rich Python object model one can only make
Python fast for a small subset of the language.

Example: in Julia I can easily define my own primitive type, let's say a
ModInteger (an old video is here [2]) and it will be as fast as a normal
"built in" integer in a for loop (and benefit from possible speedups: simd,
parallelization, cuda, GPU - but don't have (much) experience in this area).

Likely such a ModInteger couldn't be as easily integrated in Numba?

[1]: [https://discourse.julialang.org/t/julia-motivation-why-
weren...](https://discourse.julialang.org/t/julia-motivation-why-werent-numpy-
scipy-numba-good-enough/2236) [2]: (2013)
[https://www.youtube.com/watch?v=rUczbQ6ZPd8](https://www.youtube.com/watch?v=rUczbQ6ZPd8)
(at ~37:00 mins)

~~~
marmaduke
Yep I was expecting you might mention user defined types. Numba supports them
but with an object model which is more sympathetic to acceleration.

The other place where Julia might see better speed is when you have an
optimization algorithm and the objective function both written in Julia, which
allows for optimization across functions, whereas in Python you could write a
fast objective function with Numba but couldn't optimize across function call
with the optimizer written in Fortran.

------
jordigh
It is interesting to note that ESI, the company that is sponsoring Scilab
development, has recently hired the lead Octave developer too:

[http://lists.gnu.org/archive/html/octave-
maintainers/2017-09...](http://lists.gnu.org/archive/html/octave-
maintainers/2017-09/msg00053.html)

This follows up on this story:

[https://news.ycombinator.com/item?id=13603575](https://news.ycombinator.com/item?id=13603575)

Furthermore, reports of the death of Matlab (in favour of Python) have been
greatly, _greatly_ exaggerated.

~~~
marmaduke
> reports of the death of Matlab (in favour of Python)

MathWorks provides a way to call Python from MATLAB with the same simplicity
as it can call Java. I don't think anyone declared MATLAB dead but it's a
clear indication that they're losing ground.

------
rattray
It's not immediately clear from the homepage how this is different from
Octave.

[https://www.gnu.org/software/octave/](https://www.gnu.org/software/octave/)

~~~
jordigh
Octave tries to make every Matlab program run unmodified. A difficult goal,
but that is the goal.

Scilab doesn't try that exactly. They have their own syntax and some
compatibility converter from Matlab code to Scilab code, but I don't thik it's
as complete as Octave's.

As a sibling comment mentions, Scilab has Xcos which tries to be a modelling
helper like Simulink and Octave has nothing comparable.

------
knolan
I’m a long term Matlab user who now enjoys using Python. Students still like
to stick to Matlab because of its pretty simple IDE and decent documentation.
The various Python IDEs like Canopy and PyCharm are too often complicated for
engineering students who just want the simplicity of Matlab’s Workspace to get
whatever problem they have solved.

~~~
CoreXtreme
There is Spyder or Jupyter for them.

~~~
knolan
Possibly, but you'll also have to break the monopoly the Mathworks have on
Universities.

------
scottlocklin
Scilab is ancient; I was using it in grad school. They also made a decision at
one point to make it just slightly incompatible with Matlab, which was
probably a mistake. Octave is actually better at this point; they've managed
to reproduce the best of Matlab's UI, which was always quite good.

While I rarely develop things in Matlab, it is worth noticing that it is a
very elegant way of expressing linear algebra and numeric oriented programs.
Python is a vastly more useful language, but numerics are an afterthought, and
expressing numerics is abominable in Python. When I'm looking up how to
implement some classic numerics algorithm, the Matlab way is usually concise
and its vector oriented operations are usually the right way to express it in
any interpreted language, as it keeps you in Lapack-land (remember, Matlab's
origins were a repl for Eispack/Linpack).

~~~
mkl
> Python is a vastly more useful language, but numerics are an afterthought,
> and expressing numerics is abominable in Python. When I'm looking up how to
> implement some classic numerics algorithm, the Matlab way is usually concise
> and its vector oriented operations are usually the right way to express it
> in any interpreted language

This is a really strange statement to me. Python has much better syntax for
vectorised operations than Matlab. I have written a great deal of both (Python
by choice, Matlab when required to), and in my experience almost everything
numerical is easier to express in Python.

Numpy is in large part a thin wrapper over fast low-level libraries, but with
an excellent well-designed interface, unlike the undesigned growth-by-
accretion of Matlab.

~~~
newen
I don't think you've worked a lot with numpy. Matrix indexing is a nightmare
in numpy and the documentation for just it is 3 pages long.

~~~
mkl
I've worked a lot with numpy (hundreds to thousands of hours, depending
exactly what you count). I've also worked with numerical arrays in several
other languages, and of those I've tried I've found numpy the cleanest and
simplest.

What specifically do you see as nightmarish?

------
drwu
As we are comparing to MATLAB.

I'm wondering why there is no comment about the toolboxes in MATLAB. Several
standard toolboxes are the main reasons, that I'm still staying in MATLAB.

------
gordaco
I thought that Scilab was well known. I used it in the uni during my degree in
Maths.

I prefer Matlab, but Scilab is still pretty decent. I haven't tried Octave, so
I can't compare the two of them.

------
gipp
How does this compare to Octave?
([https://www.gnu.org/software/octave/](https://www.gnu.org/software/octave/))

~~~
alfla
I believe Scilab has a Simulink equivalent, whereas I do not think Octave
does?

I'm a control engineer by training, and to be honest there's really no
equivalent to Matlab/Simulink right now for control system design. Fortunately
I'm currently working on statistics/sensor-fusion related stuff, and Python
works just fine for that.

~~~
hsjoberg
I tried doing sensor fusion with simulink and I thought it was horrible. Then
me and my team switched to python instead and it worked really well. Never
understood why to use simulink for other things then just controls.

------
alfla
I would suggest you add "Simulink" to the title, i.e. "An open-source
alternative to Matlab/Simulink".

------
leovailati
I am surprised that Julia hasn't been mentioned yet. It is the
language/program that I normally use when I don't want or for some reason
cannot use MATLAB. Many times I don't want to start MATLAB because of how ling
that process takes on my computer, especially for easy tasks. I definitely
recommend checking out Julia.

Main website: [https://julialang.org/](https://julialang.org/) Cloud:
[https://www.juliabox.com/](https://www.juliabox.com/) "Batteries included"
IDE:
[https://juliacomputing.com/products/juliapro](https://juliacomputing.com/products/juliapro)

~~~
cwyers
Um, Julia has been mentioned.

~~~
leovailati
You are right, I am sorry about that. I didn't catch it the first time I
skimmed through the comments.

------
aswanson
As soon as you ask me for a name,email, DNA sample, etc for a download...you
lose. Python doesn't do that. Which is why it is kicking Scilab, Matlabs et al
arse.

------
transverse
Also, how does it compare to
[http://www.sagemath.org/](http://www.sagemath.org/)

~~~
mixedmath
sagemath is monolithic, and incorporates many other foss libraries within it.
Other commenters here are discussing comparing scilab with Octave, and
sagemath includes all of Octave.

~~~
williamstein
I wish — unfortunately, SageMath doesn’t actually include Octave. I tried to
include Octave at one point, but it took far too long to build from source and
replicated too much functionality already available in Numpy/Scipy to make it
worth the work at the time. I did write a (maybe not so great) pexpect
interface between Sage and Octave, and there is also a Jupyter kernel that
lets you call Octave from Python. Similar remarks apply to SciLab. A big point
of Sage after all is getting open source math software to work together rather
than compete. We are all on the same team!

