News
Services
Products
Octave
Scilab
Tela
Comparison
Contact us!
Miscellaneous
About
Sitemap
» Help authoring program to create CHM HTML Help manuals » replace your notebook panel


System comparison
We have set a sideby 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 buildin, but could be loaded from a library, which is a nontrivial task. If the function exists, it leaves something to be desired. 

good 
Feature or functionality is not buildin, but can be loaded from a library in an easy way, typically a oneliner. If the function exists, its interface and implementation are well though out. 

very good 
Feature is builtin and can be requested immediately without any further ado. If the function exists, it provides great functionality. 
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 Cconvention: zero means false, and anything else is true. 
First class type, e.g. matrices and hypermatrices are fully supported. 
Cconvention: 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 metafunctions 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 columnvectors; 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 columnvectors.
 Hypermatrices, i.e. objects of rank greater than two, are processed very slowly.

Support for hypermatrices 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 Clike notation (dot separates identifiers). 
Implementable via tlist, or mlist types. 
 Completely unsupported. 
Hash 
o Implementable via lists. 
o Implementable via mlist types. 
 Completely unsupported. 
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, 01i, 3 4i 
Vector construction 
v0 = [2.3 3e2 7.2e4] # row vector
v1 = [3.9e14, 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.2e4] // row vector
v1 = [3.9e14, 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.2e4)
v1 = #(v0, v0, v0)

Vector display 
v0 =
2.3000e 00 3.0000e 02 7.2000e04
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/MatrixOperators 
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 linecontinuation 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 mfile of the same name and sourcees it (automatic loading). To load a file explicitely, use source("filename") 
getf("scifile") functions are can be loaded automagically via (user)library. (Single quotes can be substituted for double quotes.) 
source("tfile"), source_silent("tfile"), autosource("tfile", "name1", ..., "nameN") 
Loading of code 
source("filename") 
exec("scifile") 
source("tfile") 
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. 
