overloading

display, functions and operators overloading capabilities

Description

In 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 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.
Operators: Each 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 a 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
            function []=%tab_p(l)
            disp([[' '; l(3)] [l(2); string(l(4))]])
            endfunction
            
            tlist('tab', ['a', 'b'], ['x'; 'y'], rand(2, 2))

//OPERATOR
            function x=%c_a_s(a, b)
            x = a + string(b);
            endfunction
            
            's' + 1

//FUNCTION
            function x=%c_sin(a)
            x = 'sin(' + a + ')'
            endfunction
            
            sin('2 * x')

Report an issue
<< macrovar	Функции	recompilefunction >>

overloading

Description

Examples

See Also