System comparison

We have set a side-by side comparison of Octave, Scilab and Tela. It is to assist potential users to choose the right system and for adepts of one system to judge the benefits or drawbacks of the other.

In this section we neither compare the performance, nor do we judge the different libraries in great detail. The comparison encompasses only the most basic features, but these are of great importance for any small or big undertaking. To ease the ranking of the quality of the features, we have introduced a little scheme, which is shown in Table Symbol explanation.

Table 3. Symbol explanation

Symbol Quality Feature
-- very bad Functionality is either not available, and it would be extremely difficult to incorporate, or it is seriously broken.
- bad Function is not available, but the system could be extended to incorporate it. Yet, there are no packages available which would provide it. If the function does exist, it is flawed.
o mediocre Feature or functionality is not build-in, but could be loaded from a library, which is a non-trivial task. If the function exists, it leaves something to be desired.
good Feature or functionality is not build-in, but can be loaded from a library in an easy way, typically a one-liner. If the function exists, its interface and implementation are well though out.
very good Feature is built-in and can be requested immediately without any further ado. If the function exists, it provides great functionality.

Types

The types a language provides make up a great deal of its appearance. The ease or difficulty in the use of the language is heavily determined by the power the various types are endowed with.

Table 4. Atomic types

  Octave Scilab Tela
Floating point including complex values o Only partly IEEE compliant.
Integer o Integral floating point values are known, but integers are not a first class data type. - Available since version 2.5, but broken. First class type.
Boolean o C-convention: zero means false, and anything else is true. First class type, e.g. matrices and hyper-matrices are fully supported. C-convention: zero means false, and anything else means true. First class boolean type is missing, but can be emulated with integers.
String o Strings exist, but loose their identity when put into a matrix as the gather operation concatenates strings. First class type. Matrices of strings can hold strings of different length in every cell. The character encoding is application specific and different from ASCII. - Strings exist but have almost no support from the library.
Functions o Functions are not a first class data type. Applying meta-functions requires a clumsy syntax, e.g., evalf(func, arg1, ..., argN). Functions can be declared online, they can be recursive, but their definitions cannot be nested. Octave strongly supports that only a single function is defined in a file (with the same name as the function). If such a file is in the search path LOADPATH, it gets sourced automatically at the time of the first call. First class type. Functions can be either defined in files, where several functions per file are possible, or defined online, i.e. during a session. Recursive functions are allowed and they execute fast. Function definitions can be nested. Functionals are supported. First class type; functions can be disassembled in Tela's own “FlatCode”. Functions can be defined in files, where several functions per file are possible, and also online, i.e. during a session. Recursive functions are allowed. Function definitions cannot be nested. Functionals are supported. Tela has a sophisticated module system, which allows the user to bundle groups of functions and control their accessibility.

Some data types are in a way atomic, but usually are not counted towards the classical atomic types like integers and characters. Therefore, we list them separately.

Table 5. Special purpose atomic types

  Octave Scilab Tela
Polynomials o Implemented with matrices, i.e. the polynomials are stored in coefficient form and there is no symbolic polynomial variable. Implemented via tlists; polynomials can be stored in coefficient form or in root form. They carry symbolic variables. o Implemented with matrices, i.e. the polynomials are stored in coefficient form and there is no symbolic polynomial variable.
Rational polynomials - Unsupported. Implemented via tlists. - Unsupported.
Arbitrary precision types o A weak binding to GiNaC exists, but it is not part of the standard distribution. - Unsupported. - Unsupported.
Linear systems Features OCST, the Octave Control Systems Toolbox. Implemented via tlists; lots of supporting functions. - Unsupported.
Quaternions - Unsupported. - Unsupported.

Next are complex (in the Latin meaning of the word ;-) data types, those holding other types like a container.

Table 6. Containers

  Octave Scilab Tela
Vectors/Matrices

First class data type; distinct row- and column-vectors; null matrices and null vectors carry a dimension.

-- No support for arrays of rank larger than two.

- Only arrays of numbers are available, and no true matrices of strings.

Distinct row- and column-vectors.

- Hypermatrices, i.e. objects of rank greater than two, are processed very slowly.

Support for hyper-matrices up to rank 8 (default: rank 4).

- Only arrays of numbers are available, and no true matrices of strings.

Lists -- Completely unsupported.
Records Direct support for structures in a C-like notation (dot separates identifiers). Implementable via tlist, or mlist types. -- Completely unsupported.
Hash o Implementable via lists. o Implementable via mlist types. -- Completely unsupported.

Peculiarities

If you are proficient with an imperative programming language or even with one of the Matlab®-clones, and you want to try another program, it is most important to know what are the peculiarities of the new one. That way you get into gear fast.

Table 7. Peculiarities

  Octave Scilab Tela
Imaginary numbers 1i, -1i, 3 4i, 1I, 1j, 1J %i, -%i, 3 4*%i 1i, -1i, 3 4i
Imaginary numbers display 0   1i, 0 - 1i, 3   4i i, - i, 3.   4.i 0 1i, -0-1i, 3 4i
Vector construction
v0 = [2.3 -3e2 7.2e-4]        # row vector
v1 = [3.9e-14, 0.0009, 0.041] # row vector
v2 = [0.1766; 0.364; 0.091]   # column vector
v4 = [v0, v1 v1]              # row vector
               
v0 = [2.3 -3e2 7.2e-4]        // row vector
v1 = [3.9e-14, 0.0009, 0.041] // row vector
v2 = [0.1766; 0.364; 0.091]   // column vector
v4 = [v0, v1 v1]              // row vector
               
v0 = #(2.3, -3e2, 7.2e-4)
v1 = #(v0, v0, v0)
               
Vector display
v0 =
    2.3000e 00   -3.0000e 02    7.2000e-04
               
v2 =
  0.176600
  0.364000
  0.091000
               
 v0  =
!   2.3  - 300.    0.00072 !
               
 v2  =
!   0.1766 !
!   0.364  !
!   0.091  !
               
#(2.3, -300, 0.00072)
Matrix construction
m0 = [0.5, 0.45443; ...
      0.23, 0.831; ...    # row 2
      0.931, 0.56806; ...
      0.556, 0.0508]
m1 = [0.875981 0.531557 0.920261; \
      0.515431 0.378377 0.678877]
m3 = [
        0.399
        0.679
        0.091
     ]
               
m0 = [0.5, 0.45443; .. 
      0.23, 0.831; ..
      0.931, 0.56806; ..
      0.556, 0.0508]
m1 = [0.875981 0.531557 0.920261; ..
      0.515431 0.378377 0.678877]
               
m0 = #(0.5095, 0.315939, 0.701703; 
       0.367247, 0.876312, 0.370995)
m1 = #(0.171142 0.0525795i, 0.830779 0.96673i;
       0.861905 0.334284i, 0.769221 0.0820965i)
               
Matrix display
m0 =
  0.500000  0.454430
  0.230000  0.831000
  0.931000  0.568060
  0.556000  0.050800
               
m1 =
  0.87598  0.53156  0.92026
  0.51543  0.37838  0.67888
               
 m0  =
!   0.5      0.45443 !
!   0.23     0.831   !
!   0.931    0.56806 !
!   0.556    0.0508  !
               
 m1  =
!   0.875981    0.531557    0.920261 !
!   0.515431    0.378377    0.678877 !
               
#(    0.5095,  0.315939,  0.701703;
    0.367247,  0.876312,  0.370995)
               
#(  0.171142 0.0525795i,    0.830779 0.96673i;
     0.861905 0.334284i,  0.769221 0.0820965i)
               
Array-/Matrix-Operators array: “ ” (addition), “-” (subtraction), “.*” (multiplication), “./” (division), “.^” (exponentiation); matrix: “*” (matrix multiplication), “\” (solve system of linear equations), “^” (matrix power). array: “ ” (addition), “-” (subtraction), “.*” (multiplication), “./” (division), “.^” (exponentiation); matrix: “*” (matrix multiplication), “\” (solve system of linear equations), “/.” (system feedback), “^” (matrix power). array: “ ” (addition), “-” (subtraction), “*” (multiplication), “/” (division), mod((a, , b)) (modulo division), “^” (exponentiation); matrix: “**”, matprod((a, , b)) (matrix multiplication), linsolve((a, , b)) (solve system of linear equations).
Comments %”  and   “#”  both continue to end of line //”  continues to end of line //”  continues to end of line (not available in interactive mode)
Line continuation ...”  or  “\”  comments after the line-continuation marks are allowed. If “\” occurs in the middle of a line it is interpreted as division operator. Octave is aware of open brackets and unfinished statements; it then implies line continuation as long as an expression has unbalanced brackets or lacks its statement terminator (e.g. end, or endfunction for function). ..”  more than two periods are valid. No explicit line continuation necessary as Tela is not line oriented; in interactive mode a request must fit on one line.
Loading of functions If Octave encounters an undefined symbol, it searches along LOADPATH for an m-file of the same name and sourcees it (automatic loading). To load a file explicitely, use source("filename") getf("sci-file")   functions are can be loaded automagically via (user-)library. (Single quotes can be substituted for double quotes.) source("t-file"), source_silent("t-file"), autosource("t-file", "name1", ..., "nameN")
Loading of code source("filename") exec("sci-file") source("t-file")
Function definition Online definition and definition in a file look the same:
function func_head
func_body
endfunction
               
where func_head has the form [result1, ..., resultN] = func_name(argument1, ..., argumentM) and func_body consists of Octave statements. endfunction can be abbreviated to end.
online definition:
deff("func_head", "func_body")
               
definition in a file:
function func_head
func_body
               
where func_head has the form [result1, ..., resultN] = func_name(argument1, ..., argumentM) and func_body consists of Scilab statements.
online definition:
function func_head { func_body };
               
definition in a file:
function func_head
{
    func_body
};
               
where func_head has the form [mand_result1, ..., mand_resultN; opt_result1, ..., opt_resultM] = func_name(mand_argument1, ..., argumentK, opt_argument1, ..., opt_argumentL) and func_body consists of Tela statements.