overloadingdisplay, functions and operators overloading
capabilities
DescriptionIn Scilab, variable display, functions and operators may be defined
for new objects using functions (Scilab coded or primitives).
Display
The display of new objects defined by tlist
structure may be overloaded (the default display is similar to
list's one). The overloading function must have
no output argument and a single input argument. It's name is formed as
follow %<tlist_type>_p where
%<tlist_type> stands for the first entry of
the tlist type component truncated to the first 9
characters.
OperatorsEach operator which is not defined for given operands type may
be defined. The overloading function must have a single output
argument and one or two inputs according to the number of operands.
The function name is formed as follow:
for binary operators:
%<first_operand_type>_<op_code>_<second_operand_type>;
for unary operators:
%<operand_type>_<op_code>;
extraction and insertion operators which are n-nary operators are
described below.
Be careful, only the types registered by the
typename function can be used in an overloading
macros.
<operand_type>,
<first_operand_type>,
<second_operand_type> are sequence of characters
associated with each data type as described in the following table:
data type
char code
typeof
comments
double matrix
s
constant
polynomial matrix
p
polynomial
boolean matrix
b
boolean
sparse matrix
sp
sparse
boolean sparse matrix
spb
boolean sparse
Matlab sparse matrix
msp
Matlab sparse
integer matrix
i
int8, int16, int32, uint8, uint16, uint32
string matrix
c
string
handle
h
handle
compiled function
fptr
fptr
script function
mc
function
library
f
library
list
l
list
tlist
tlist type
tlist type
the first string in the first tlist entry
mlist
mlist type
mlist type
the first string in the first mlist entry
hypermatrix
hm
hypermat
pointer
ptr
pointer
cell
ce
ce
structure
st
st
rational
r
rational
linear state space
lss
state-space
implicit polynom
ip
size implicit
1:1:$
<op_code> is a single character associated
with each operator as described in the following table:
op
char code
'
t
+
a
-
s
*
m
/
r
\
l
^
p
.*
x
./
d
.\
q
.*.
k
./.
y
.\.
z
:
b
*.
u
/.
v
\.
w
[a,b]
c
[a;b]
f
() extraction
e
() insertion
i
==
o
<>
n
|
g
&
h
.^
j
.'
0
<
1
>
2
<=
3
>=
4
~
5
iext
6
The overloading function for extraction syntax b= a(i1,
..., in)
has the following calling sequence: b =
%<type_of_a>_e_(i1, ..., in, a)
and the syntax [x1, .., xm] = a(i1, ..., in) has
the following calling sequence: [x1, .., xm] =
%<type_of_a>_e_(i1, ..., in, a)
.
The overloading function associated to the insertion syntax
a(i1, ..., in) = b has the following calling sequence:
a = %<type_of_b>_i_<type_of_a>(i1, ..., in, b,
a)
.
The 6 char code may be used for some complex
insertion algorithm like x.b(2) = 33 where
b field is not defined in the structure
x. The insertion is automatically decomposed into
temp = x.b; temp(2) = 33;
x.b = temp. The 6 char code is used
for the first step of this algorithm. The 6 overloading
function is very similar to the e's one.
Functions :
Some basic primitive function may also be overloaded for new data type. When such function
is undefined for a particular data types the function
%<type_of_an_argument>_<function_name>
is called. User may add in this called function the definition
associated with the input data types.
Examples//DISPLAY
var = tlist('tab', ['a', 'b'], ['x'; 'y'], rand(2, 2)) // the type of var is 'tab'
typeof(var)
function [] = %tab_p(l)
disp([[' '; l(3)] [l(2); string(l(4))]])
endfunction
var // after overloading
//OPERATOR
's' + 1 // it is impossible to add a number to a string
function x = %c_a_s(a, b)
x = a + string(b);
endfunction
's' + 1 // after overloading
//FUNCTION
sin('2 * x') // the sin function does not work with a string
function x = %c_sin(a)
x = 'sin(' + a + ')'
endfunction
sin('2 * x') // after overloading
See Also
tlist
disp
symbols
typeof
type
typename